package New;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;

/**
 * 如果一个接口中，只声明了一个抽象方法，则称此接口为函数式接口
 * 可以通过lambda表达式来创建该吉克欧的对象，如果lambda表达式
 * 抛出一个非运行时异常，那么该异常需要在目标接口的抽象方法上声明
 * java 内置的四大核心函数式接口
 * 1.消费型接口  Consume<T>  参数  T     返回类型为 void   包含方法：void accept(T t)
 * 对类型为T的对象应用操作
 * 2.供给型接口  Supplier<T> 参数 无     返回类型为 T       包含方法：T get()
 * 返回类型为T的对象
 * 3.函数性接口  Function<T,R> 参数 T    返回类型   R      包含方法：R apply(T t)
 * 对类型为T的对象应用操作，并返回结果是R类型的对象
 * 4.断定型接口  Predicate<T>  参数 T    返回类型  boolean  包含方法：boolean test(T t)
 * 确定类型为T的对象是否满足某约束，并返回boolean值
 */


public class LambdaTest2 {
    @Test
    public void test1(){
        happyTime(550, new Consumer<Double>() {
            @Override
            public void accept(Double aDouble) {
                System.out.println("消费型接口"+aDouble);
            }
        });
        happyTime(550, aDouble -> System.out.println("lambda表达式"+aDouble));
    }
    public void happyTime(double money, Consumer<Double> con){
        con.accept(money);
    }
    @Test
    public void test2(){
        List<String> list = Arrays.asList("北京","天津","南京","东京","普京");
       List<String> filterStrs = filterString(list, new Predicate<String>() {
           @Override
           public boolean test(String s) {
               return s.contains("京");
           }
       });

        System.out.println(filterStrs);
        List<String> filterStrs1 =filterString (list, s -> s.contains("京"));
        System.out.println(filterStrs1);
    }
//    根据给定的规则，过滤集合中的字符串，此规则由Predicate的方法决定
    public List<String> filterString (List<String> list, Predicate<String> pre){
        ArrayList<String> filterList = new ArrayList<>();
        for (String s : list) {
            if(pre.test(s)){
                filterList.add(s);
            }
        }
        return filterList;

    }
}
